package com.honghe.system.service.impl;
import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
import java.util.*;
import java.util.stream.Collectors;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.honghe.system.domain.CustomerContactRecord;
import com.honghe.system.domain.vo.CustomerContactStatsVO;
import com.honghe.system.domain.vo.HandlerContactStatsResultVO;
import com.honghe.system.mapper.CustomerContactRecordMapper;
import com.honghe.system.service.ICustomerContactStatsService;
import java.math.BigDecimal;

/**
 * 客户联系记录统计Service实现
 */
@Service
public class CustomerContactStatsServiceImpl implements ICustomerContactStatsService {
    @Autowired
    private CustomerContactRecordMapper contactRecordMapper;

    /**
     * 查询联系记录列表
     */
    @Override
    public List<CustomerContactRecord> selectContactList(CustomerContactStatsVO customerContactStats) {
        return contactRecordMapper.selectContactList(customerContactStats);
    }

    /**
     * 获取联系记录统计数据
     */
    @Override
    public CustomerContactStatsVO getContactStatistics(CustomerContactStatsVO customerContactStats) {
        CustomerContactStatsVO stats = new CustomerContactStatsVO();
        
        // 获取总联系次数
        stats.setTotalContacts(contactRecordMapper.selectTotalContacts(customerContactStats));
        
        // 获取本月联系次数
        stats.setMonthlyContacts(contactRecordMapper.selectMonthlyContacts(customerContactStats));
        
        // 计算平均联系频率
        Double avgFrequency = contactRecordMapper.selectAverageFrequency(customerContactStats);
        stats.setAverageFrequency(avgFrequency != null ? avgFrequency : 0.0);
        
        // 获取活跃客户数
        stats.setActiveCustomers(contactRecordMapper.selectActiveCustomers(customerContactStats));
        
        // 获取趋势数据
        List<Map<String, Object>> trendData = contactRecordMapper.selectContactTrend(customerContactStats);
        List<String> trendDates = new ArrayList<>();
        List<Integer> trendCounts = new ArrayList<>();
        
        // 处理趋势数据
        if (!trendData.isEmpty()) {
            DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");
            LocalDate startDate = LocalDate.parse(trendData.get(0).get("date").toString(), formatter);
            LocalDate endDate = LocalDate.parse(trendData.get(trendData.size() - 1).get("date").toString(), formatter);
            
            Map<String, Integer> dateCountMap = trendData.stream()
                .collect(Collectors.toMap(
                    item -> item.get("date").toString(),
                    item -> Integer.parseInt(item.get("count").toString())
                ));
            
            LocalDate currentDate = startDate;
            while (!currentDate.isAfter(endDate)) {
                String dateStr = currentDate.format(formatter);
                trendDates.add(dateStr);
                trendCounts.add(dateCountMap.getOrDefault(dateStr, 0));
                currentDate = currentDate.plusDays(1);
            }
        }
        
        stats.setTrendDates(trendDates);
        stats.setTrendCounts(trendCounts);
        
        // 获取联系方式分布
        List<Map<String, Object>> contactTypes = contactRecordMapper.selectContactTypeDistribution(customerContactStats);
        stats.setContactTypes(contactTypes);
        
        return stats;
    }

    /**
     * 获取负责人联系记录统计数据（基于Map参数）
     */
    @Override
    public HandlerContactStatsResultVO getHandlerContactStats(Map<String, Object> params) {
        HandlerContactStatsResultVO result = new HandlerContactStatsResultVO();
        
        try {
            // 性能监控 - 记录开始时间
            long startTime = System.currentTimeMillis();
            System.out.println("开始获取负责人联系统计数据，参数: " + params);
            
            // 优化1: 转换参数时使用传统API以提高性能
            CustomerContactStatsVO statsVO = new CustomerContactStatsVO();
            
            // 参数处理 - 使用安全的方式获取参数
            if (params.containsKey("customerName")) {
                statsVO.setCustomerName(String.valueOf(params.get("customerName")));
            }
            
            // 优化2: 使用三元运算符简化代码
            statsVO.setPageNum(params.containsKey("pageNum") ? 
                    Integer.parseInt(String.valueOf(params.get("pageNum"))) : null);
            statsVO.setPageSize(params.containsKey("pageSize") ? 
                    Integer.parseInt(String.valueOf(params.get("pageSize"))) : null);
            
            // 设置handlerName参数 - 不重复设置相同的key
            if (params.containsKey("handlerName")) {
                System.out.println("使用特定的handlerName筛选条件: " + params.get("handlerName"));
            }
            
            // 设置参数Map (包含startDate和endDate)
            statsVO.setParams(params);

            // 性能监控 - SQL查询开始
            long sqlStartTime = System.currentTimeMillis();
            
            // 获取统计列表
            List<Map<String, Object>> statsList = contactRecordMapper.selectHandlerContactStats(statsVO);
            
            // 性能监控 - SQL查询结束
            long sqlEndTime = System.currentTimeMillis();
            System.out.println("SQL查询执行时间: " + (sqlEndTime - sqlStartTime) + "ms, 返回记录数: " + 
                    (statsList != null ? statsList.size() : 0));
            
            // 记录是否已找到notFollowedCount字段
            boolean foundNotFollowedCount = false;
            
            // 优化3: 批量处理数据 - 只遍历一次列表
            if (statsList != null && !statsList.isEmpty()) {
                // 性能监控 - 数据处理开始
                long processStartTime = System.currentTimeMillis();
                
                for (Map<String, Object> stats : statsList) {
                    // 使用更简洁的日志格式
                    String handlerName = String.valueOf(stats.get("handlerName"));
                    System.out.println("\n=== 处理负责人: " + handlerName + " ===");
                    
                    // 优化4: 使用统一的转换方法避免重复代码
                    int customerCount = getIntValue(stats, "customerCount"); 
                    int contactedCustomerCount = getIntValue(stats, "contactedCustomerCount");
                    int notFollowedCount = getIntValue(stats, "notFollowedCount");
                    
                    if (stats.containsKey("notFollowedCount")) {
                        foundNotFollowedCount = true;
                    }
                    
                    // 数据一致性检查
                    System.out.println("数据一致性: [客户总数=" + customerCount + 
                            ", 已联系=" + contactedCustomerCount + 
                            ", 未跟进=" + notFollowedCount + 
                            ", 合计=" + (contactedCustomerCount + notFollowedCount) + "]");
                    
                    // 优化5: 使用简单的布尔表达式提高可读性
                    boolean isConsistent = (customerCount == contactedCustomerCount + notFollowedCount);
                    
                    // 如果数据不一致或未跟进数为0但存在未联系客户，进行修正
                    if (!isConsistent || (notFollowedCount == 0 && customerCount > contactedCustomerCount)) {
                        int expectedNotFollowed = Math.max(0, customerCount - contactedCustomerCount);
                        
                        System.out.println("执行数据修正: 未跟进客户数 " + 
                                notFollowedCount + " → " + expectedNotFollowed);
                        
                        // 更新未跟进客户数
                        stats.put("notFollowedCount", expectedNotFollowed);
                    }
                }
                
                // 性能监控 - 数据处理结束
                long processEndTime = System.currentTimeMillis();
                System.out.println("数据处理执行时间: " + (processEndTime - processStartTime) + "ms");
            }
            
            // 获取趋势数据 - 使用单独的计时器
            long trendStartTime = System.currentTimeMillis();
            List<Map<String, Object>> trendData = contactRecordMapper.selectHandlerContactTrends(params);
            
            // 优化6: 使用增强的处理趋势数据方法
            HandlerContactStatsResultVO.TrendData processedTrendData = processTrendDataOptimized(trendData);
            long trendEndTime = System.currentTimeMillis();
            System.out.println("趋势数据处理时间: " + (trendEndTime - trendStartTime) + "ms");
            
            result.setCode(200);
            result.setMsg("获取数据成功");
            result.setStatsList(statsList);
            result.setTrendData(processedTrendData);
            
            // 性能监控 - 总执行时间
            long endTime = System.currentTimeMillis();
            System.out.println("总执行时间: " + (endTime - startTime) + "ms");
            
        } catch (Exception e) {
            System.err.println("获取负责人联系统计数据失败: " + e.getMessage());
            e.printStackTrace();
            result.setCode(500);
            result.setMsg("获取数据失败：" + e.getMessage());
        }
        
        return result;
    }
    
    /**
     * 获取Map中的整数值，安全处理各种类型
     */
    private int getIntValue(Map<String, Object> map, String key) {
        Object value = map.get(key);
        if (value == null) {
            return 0;
        }
        
        try {
            if (value instanceof Integer) {
                return (Integer) value;
            } else if (value instanceof Long) {
                return ((Long) value).intValue();
            } else if (value instanceof BigDecimal) {
                return ((BigDecimal) value).intValue();
            } else {
                return Integer.parseInt(String.valueOf(value));
            }
        } catch (Exception e) {
            System.out.println("转换" + key + "值时出错: " + e.getMessage());
            return 0;
        }
    }
    
    /**
     * 优化版处理趋势数据
     */
    private HandlerContactStatsResultVO.TrendData processTrendDataOptimized(List<Map<String, Object>> trendData) {
        HandlerContactStatsResultVO.TrendData result = new HandlerContactStatsResultVO.TrendData();
        
        if (trendData == null || trendData.isEmpty()) {
            // 如果没有数据，返回默认的空趋势数据结构
            result.setDates(new ArrayList<>());
            result.setHandlers(new ArrayList<>());
            result.setData(new HashMap<>());
            return result;
        }
        
        // 优化1: 使用Stream API提取唯一的handler和date
        Set<String> handlers = trendData.stream()
                .map(data -> String.valueOf(data.get("handler")))
                .collect(Collectors.toSet());
        
        // 确保日期有序
        Set<String> dates = trendData.stream()
                .map(data -> String.valueOf(data.get("date")))
                .collect(Collectors.toCollection(TreeSet::new));
        
        System.out.println("处理趋势数据: 负责人数量=" + handlers.size() + ", 日期数量=" + dates.size());
        
        // 优化2: 使用Map预处理数据，减少嵌套循环
        Map<String, Map<String, Integer>> dataByHandlerAndDate = new HashMap<>();
        
        for (Map<String, Object> data : trendData) {
            String handler = String.valueOf(data.get("handler"));
            String date = String.valueOf(data.get("date"));
            int count = Integer.parseInt(String.valueOf(data.get("count")));
            
            Map<String, Integer> handlerData = dataByHandlerAndDate.computeIfAbsent(handler, k -> new HashMap<>());
            handlerData.put(date, count);
        }
        
        // 优化3: 一次性构建结果，不进行多次列表查找
        Map<String, List<Integer>> resultData = new HashMap<>();
        List<String> datesList = new ArrayList<>(dates);
        
        for (String handler : handlers) {
            List<Integer> counts = new ArrayList<>();
            Map<String, Integer> handlerData = dataByHandlerAndDate.getOrDefault(handler, Collections.emptyMap());
            
            for (String date : dates) {
                counts.add(handlerData.getOrDefault(date, 0));
            }
            
            resultData.put(handler, counts);
        }
        
        result.setDates(new ArrayList<>(dates));
        result.setHandlers(new ArrayList<>(handlers));
        result.setData(resultData);
        
        return result;
    }

    /**
     * 获取负责人联系记录统计数据
     */
    @Override
    public List<Map<String, Object>> getHandlerContactStats(CustomerContactStatsVO customerContactStats) {
        try {
            // 获取统计列表
            List<Map<String, Object>> statsList = contactRecordMapper.selectHandlerContactStats(customerContactStats);
            return statsList;
        } catch (Exception e) {
            throw new RuntimeException("获取负责人统计数据失败：" + e.getMessage(), e);
        }
    }
} 